home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C++ / Code Resources / Windows 95 MDEF / Sourcery / DrawMenuItem.cpp next >
Encoding:
C/C++ Source or Header  |  1996-06-12  |  7.8 KB  |  289 lines  |  [TEXT/CWIE]
  1. #include "DrawMenuItem.h"
  2. #include "Win95Look.h"
  3.  
  4. void DrawItemSeparator(Rect *itemRect, MDEFstuff *mdefData);
  5.  
  6. void DrawItemMark(
  7.     char        theMark,
  8.     short        hiliteState,
  9.     Rect        *itemRect,
  10.     MDEFstuff    *mdefData);
  11.  
  12. void DrawMenuItemText(
  13.     Str255        itemText,
  14.     short        hiliteState,
  15.     short        itemMarkOffset,
  16.     Rect        *itemRect,
  17.     MenuHandle    whichMenu,
  18.     short        menuItem,
  19.     MDEFstuff    *mdefData);
  20.  
  21. void DrawSubMenuTriangle(
  22.     Rect *itemRect,
  23.     short hiliteState,
  24.     MDEFstuff *mdefData);
  25.  
  26. void DrawCmdKey(
  27.     char        theChar,
  28.     short        hiliteState,
  29.     Rect        *itemRect,
  30.     MDEFstuff    *mdefData);
  31.  
  32. // ---------------------------------------------------------------------------
  33.  
  34. // DrawMenuItem.
  35. // The "meat" of this MDEF. Does the actual drawing.
  36. // Draws the menu item's frame, item text, cmd-keys, and submenu symbols.
  37. // It does this and also accounts for menu item's enabled/disabled status,
  38. // among other things. Pretty tedious.
  39.  
  40. void DrawMenuItem(MenuHandle whichMenu, Rect *menuRect, short whichItem,
  41.                     short hiliteState, MDEFstuff *mdefData) {
  42.     Str255    itemText;
  43.     Rect    itemRect;
  44.     Boolean    itemDisabled;
  45.     short    itemMarkOffset = 0;
  46.  
  47.     // Get text of menu item.
  48.     GetItem(whichMenu, whichItem, itemText);
  49.  
  50.     // Determine menu item's rect.
  51.     GetMenuItemRect(menuRect, &itemRect, whichItem);
  52.     // Do some rect clipping & fudging
  53.     InsetRect(&itemRect, kRectPadding, kRectPadding);
  54.  
  55.     // Catch special menu item cases, such as the dividing line "(-"
  56.     if (itemText[1] == kDividerChar) {
  57.         DrawItemSeparator(&itemRect, mdefData);
  58.         return; // No more to draw, so exit
  59.     }
  60.  
  61.     itemDisabled = IsItemDisabled(whichMenu, whichItem);
  62.  
  63.     if (hiliteState == kMenuUnhilited) {
  64.         RGBForeColor(&(mdefData->params).menuBkgndColor);
  65.         PaintRect(&itemRect);
  66.     }
  67.     else {
  68.         RGBForeColor(&(mdefData->params).menuSelectionColor);
  69.         PaintRect(&itemRect);
  70.     }
  71.  
  72.     if (itemDisabled)
  73.         hiliteState = kMenuDisabled;
  74.  
  75.     // Draw item mark, if any. Remember to note if menu item is disabled or not
  76.     itemMarkOffset = CharWidth(kCheckMarkChar) + kItemMarkPadding;
  77.     short theMark, theChar;
  78.     GetItemMark(whichMenu, whichItem, &theMark);
  79.     GetItemCmd(whichMenu, whichItem, &theChar);
  80.     if (theMark != noMark && theChar != hMenuCmd) {
  81.         // Not a submenu, but an actual item mark, so we have to draw it
  82.         DrawItemMark(theMark, hiliteState, &itemRect, mdefData);
  83.     }
  84.  
  85.     // Now time to draw the menu item text itself...
  86.     DrawMenuItemText(itemText, hiliteState, itemMarkOffset,
  87.         &itemRect, whichMenu, whichItem, mdefData);
  88.     
  89.     // Alright, time to draw Cmd-keys and/or submenu triangles
  90.     switch(theChar) {
  91.         case kSubmenuCode:
  92.             DrawSubMenuTriangle(&itemRect, hiliteState, mdefData);
  93.         break;
  94.         
  95.         case kScriptCode:
  96.         case kUseICONCode:
  97.         case kUseSICNCode:
  98.             // Not supported in this version. Do nothing.
  99.         break;
  100.         
  101.         default:
  102.             if (theChar != 0)
  103.                 DrawCmdKey(theChar, hiliteState, &itemRect, mdefData);
  104.         break;
  105.     }
  106. } // END DrawMenuItem
  107.  
  108. // ---------------------------------------------------------------------------
  109.  
  110. void DrawItemSeparator(Rect *itemRect, MDEFstuff *mdefData) {
  111.     // Find height of menu item, divided by two
  112.     short halfWay = (itemRect->bottom - itemRect->top) / 2;
  113.  
  114.     MoveTo(itemRect->left + 1, itemRect->top + halfWay);
  115.     W95LineTo(itemRect->right - 1, itemRect->top + halfWay,
  116.         &(mdefData->params).menuShadowColor,
  117.         &(mdefData->params).menuHiliteColor);
  118. } // END DrawItemSeparator
  119.  
  120. // ---------------------------------------------------------------------------
  121.  
  122. /*
  123.     Always use system font for drawing item marks, so checkmarks, bullets,
  124.     etc. will always be available no matter what font the user is using
  125.     for the menu text...
  126. */
  127. void DrawItemMark(
  128.     char        theMark,
  129.     short        hiliteState,
  130.     Rect        *itemRect,
  131.     MDEFstuff    *mdefData) {
  132.  
  133.     short textLocH, textLocV;
  134.     RGBColor *textColor;
  135.  
  136.     textLocH = itemRect->left + kWidthPadding;
  137.     textLocV = itemRect->bottom - kHeightPadding + kTextHtPadding;
  138.     TextFont(systemFont);
  139.  
  140.     MoveTo(textLocH, textLocV);
  141.     if (hiliteState != kMenuDisabled)
  142.         textColor = &(mdefData->black);
  143.     else
  144.         textColor = &(mdefData->params).menuShadowColor;
  145.     W95DrawChar(theMark, textColor, &(mdefData->params).menuHiliteColor);
  146.  
  147.     TextFont((mdefData->params).menuFont);
  148. } // END DrawItemMark
  149.  
  150. // ---------------------------------------------------------------------------
  151.  
  152. /*
  153.     The menuFace parameter in the 'MnuT' resource defines the textFace for
  154.     the entire menu. If however, an individual menu item has a text style
  155.     other than plain, it will override the settings in the 'MnuT' resource
  156.     for that menu.
  157. */
  158.  
  159. void DrawMenuItemText(
  160.     Str255        itemText,
  161.     short        hiliteState,
  162.     short        itemMarkOffset,
  163.     Rect        *itemRect,
  164.     MenuHandle    whichMenu,
  165.     short        menuItem,
  166.     MDEFstuff    *mdefData) {
  167.  
  168.     short textLocH, textLocV;
  169.     Style textStyle;
  170.     RGBColor *textColor;
  171.  
  172.     GetItemStyle(whichMenu, menuItem, &textStyle);
  173.     if (textStyle) {
  174.         TextFace(textStyle);
  175.     }
  176.  
  177.     /*
  178.         Determine which colors to draw the text in, based on whether
  179.         the text is disabled, and whether we adhere strictly to
  180.         the Windows95 look.
  181.     */
  182.     if (hiliteState == kMenuDisabled) {
  183.         textColor = &(mdefData->params).menuShadowColor;
  184.     }
  185.     else {
  186.         if ((mdefData->params).exactWin95Look) {
  187.             if (hiliteState == kMenuHilited)
  188.                 textColor = &mdefData->white;
  189.             else
  190.                 textColor = &mdefData->black;
  191.         }
  192.         else
  193.             textColor = &mdefData->black;
  194.     }
  195.  
  196.     textLocH = itemRect->left + kWidthPadding - 1 + itemMarkOffset;
  197.     textLocV = itemRect->bottom - kHeightPadding + kTextHtPadding;
  198.  
  199.     /*
  200.         If the item is disabled, or if we're not using the "exact"
  201.         Windows95 look, we draw the text embossed. Else we draw
  202.         the text plainly.
  203.     */
  204.     if (hiliteState == kMenuDisabled || !(mdefData->params).exactWin95Look) {
  205.         W95DrawTextAt((Ptr)&itemText[1], itemText[0],
  206.             textLocH, textLocV, textColor, &(mdefData->params).menuHiliteColor);
  207.     }
  208.     else {
  209.         RGBForeColor(textColor);
  210.         MoveTo(textLocH, textLocV);
  211.         DrawString(itemText);
  212.     }
  213.     
  214.     TextFace((mdefData->params).menuFace);
  215. } // END DrawMenuItemText
  216.  
  217. // ---------------------------------------------------------------------------
  218.  
  219. void DrawSubMenuTriangle(
  220.     Rect *itemRect,
  221.     short hiliteState,
  222.     MDEFstuff *mdefData) {
  223.  
  224.     // Draw submenu symbol
  225.     Rect subMenuRect;
  226.     RGBColor *lineColor;
  227.     RGBColor *hiliteColor;
  228.     RGBColor fillColor;
  229.  
  230.     SetRect(&subMenuRect, 0, 0, kSubMenuWd, kSubMenuHt);
  231.     subMenuRect.top = (itemRect->top +
  232.         ((itemRect->bottom - itemRect->top) / 2)) - (kSubMenuHt / 2);
  233.     subMenuRect.right = itemRect->right - kRectPadding - 4;
  234.     subMenuRect.left = subMenuRect.right - kSubMenuWd;
  235.     subMenuRect.bottom = subMenuRect.top + kSubMenuHt;
  236.  
  237.     if ((mdefData->params).exactWin95Look) {
  238.         if (hiliteState == kMenuHilited) {
  239.             fillColor.red = fillColor.green = fillColor.blue = 0xFFFF;
  240.         }
  241.         else if (hiliteState == kMenuUnhilited) {
  242.             fillColor.red = fillColor.green = fillColor.blue = 0x0000;
  243.         }
  244.         else {
  245.             // Disabled.
  246.             fillColor = (mdefData->params).menuShadowColor;
  247.         }
  248.         lineColor = hiliteColor = &fillColor;
  249.     }
  250.     else {
  251.         lineColor = &(mdefData->black);
  252.         hiliteColor = &(mdefData->params).menuHiliteColor;
  253.     }
  254.  
  255.  
  256.     W95DrawTriangleRight(&subMenuRect, (mdefData->params).exactWin95Look,
  257.         lineColor, hiliteColor, &fillColor);
  258. } // END DrawSubMenuTriangle
  259.  
  260. // ---------------------------------------------------------------------------
  261.  
  262. void DrawCmdKey(
  263.     char        theChar,
  264.     short        hiliteState,
  265.     Rect        *itemRect,
  266.     MDEFstuff    *mdefData) {
  267.  
  268.     short textLocH, textLocV;
  269.     short cmdWidth;
  270.     RGBColor *textColor;
  271.     
  272.     cmdWidth = CharWidth(kWidestChar);        // "W" is widest character (I think)
  273.     cmdWidth += CharWidth(kCmdKeyChar);        // "Cmd" key character
  274.     textLocH = itemRect->right - (kCmdKeyPadding + cmdWidth);
  275.     textLocV = itemRect->bottom - kHeightPadding + kTextHtPadding;
  276.  
  277.     if (hiliteState != kMenuDisabled)
  278.         textColor = &mdefData->black;
  279.     else
  280.         textColor = &(mdefData->params).menuShadowColor;
  281.     TextFont(systemFont);
  282.     TextFace(0);
  283.     MoveTo(textLocH, textLocV);
  284.     W95DrawChar(kCmdKeyChar, textColor, &(mdefData->params).menuHiliteColor);
  285.  
  286.     TextFont((mdefData->params).menuFont);
  287.     TextFace((mdefData->params).menuFace);
  288.     W95DrawChar(theChar, textColor, &(mdefData->params).menuHiliteColor);
  289. } // END  DrawCmdKey